home *** CD-ROM | disk | FTP | other *** search
/ GFX Sensations 1 / Graphic Sensations - Volume 1.iso / tools / amiga / gfx_card / opcd40.lha / opalpcd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-16  |  62.3 KB  |  1,827 lines
  1. /* opalpcd.c v0.30
  2.        program to display PhotoCD  pictures and save them to OpalVision
  3.    files and display.  This will read the file and convert it to a 
  4.    virtual screen which may be saved in a JPEG or IFF24 file.
  5.    
  6.    
  7.    This program is based on hpcdtoppm by Hadmut Danisch  
  8.    
  9.    OH Yeah, Its going to take helluva lotta memory 
  10.                        base =1.5m, 4base=6meg, 16base =24m 
  11.                        Picked up and adapted by BAZZ on 3-2-93
  12. I will have to use RGB toOV, and may have to break it up into
  13.  several modules to save RAM. 
  14.  
  15.     Additions © BAZZ 1993, and similar conditions as Hadmut states apply, that
  16. is pass it around all you want, but dont take credit for it (unless you 
  17. add to it) and don't distribute for profit.  This is intended to enrich the 
  18. Amiga community and is for educational purposes only.
  19.  
  20. I MAINTAIN HADMUT'S CONVENTION OF LEVEL 2 FILE AND MEMORY ACCESS WHICH CLOSES
  21. OR FREES AUTOMATICALLY UPON EXIT, AND IS MORE PORTABLE CODE.
  22.  
  23.  
  24.     Rev .20
  25.     As of 3-8 I had resolutions up thru Base working.  The decompression isnt
  26. working right on 4Base and is being looked into.  This will print out on an
  27. OpalVision screen.  The library should allown IFF24 conversion and is included
  28. with many utilities.  It might work without it but not guaranteed.    
  29.        
  30.        
  31.     Rev .30      
  32.     As of April 15, Resolution 4 is working now but takes a machine with
  33. 12 Meg of FAST Ram to load the entire picture.  With 6-8 Meg fast you can 
  34. crop parts out.  Unfortunately the requirement is h*w*6, and the only way
  35. around it is radically rewriting the code.  I have no incentive to do this
  36. since I have enough memory, and resolution 5 (3072x2048) isn't working yet.
  37. doing a 'dummy test' found that none of the compression beyond the first
  38. Luma compression worked.  When this works, I'll consider it. 
  39.     The Overview mode is fixed now and shows 16 small pictures on a page. 
  40. Pressing right button goes to next page, and pressing left exits.  When
  41. the top is reached it cycles back to the first page.  
  42.     Also fixed a bug that left Opal screen open if an error is encountered.
  43.                
  44.     Rev .40
  45.     May 12, 1993
  46.     Allows start of slideshow( -p) mode anywhere.  Slideshow keeps repeating
  47. until mouse held down.  When last picture is shown it goes back to first      
  48. Uses virtul memory sort of. 
  49.      For resolutions 4 and 5, option -v allows 
  50. loading and most conversion then storing to hard disk.  Memory is freed and
  51. then reloaded in small bits to the Opalvision screen which now has the 
  52. lion's share of memory available.  Adds a few seconds, but is the ONLY way
  53. most can use resolution 5.                 
  54.                
  55.        This was compiled using SAS/C® V 6.02
  56.                */
  57.  
  58.  
  59. /* hpcdtoppm (Hadmut's pcdtoppm) v0.1
  60. *  Copyright (c) 1992 by Hadmut Danisch (danisch@ira.uka.de).
  61. *  Permission to use and distribute this software and its
  62. *  documentation for noncommercial use and without fee is hereby granted,
  63. *  provided that the above copyright notice appear in all copies and that
  64. *  both that copyright notice and this permission notice appear in
  65. *  supporting documentation. It is not allowed to sell this software in 
  66. *  any way. This software is not public domain.
  67.         Here it is.  This file IS supporting documentation -BAZZ
  68.  
  69. */
  70. #define xDEBUG
  71. /* extern char *malloc(); */
  72.  
  73. #include <proto/all.h>
  74. #include <opal/opallib.h>
  75. #include <graphics/gfxbase.h>
  76. #include <stdio.h>
  77. #include <stdlib.h>
  78. #include <ctype.h>
  79. #include <String.h>
  80. #include <dos.h>
  81. #include <intuition/intuition.h>
  82. #include <intuition/intuitionbase.h>
  83. #include <libraries/asl.h>
  84. #include <exec/execbase.h>
  85. #include <graphics/gfxmacros.h>
  86. #include <hardware/custom.h>
  87. #
  88. #include <devices/timer.h>
  89. #include <workbench/startup.h>
  90. #include <time.h>
  91.  
  92. #include <math.h>  /* lets give it something to REALLY Render */
  93. #include <m68881.h> /* use co pro wherever possible */
  94.  
  95. typedef unsigned long dim;
  96.  
  97. #define BaseW ((dim)768)
  98. #define BaseH ((dim)512)
  99.  
  100. #define   DISP_W   736
  101. #define   DISP_H   476 /* hi-res screen */ 
  102.  
  103.  
  104. #define slen 3072 /* try to keep all defines here! */
  105.  
  106.  
  107. #define SECSIZE 0x800 /* 2k for CDrom */
  108. #define RBMASK  0x0400 
  109.  
  110. #define ASKIP { argc--; argv ++;}
  111. #define ABACK { argc++; argv --;} /* added incase we have something wrong */    
  112.  
  113. #define SeHead   2
  114. #define L_Head   (1+SeHead)
  115.  
  116. #define SeBase16 18
  117. #define L_Base16 (1+SeBase16)
  118.  
  119. #define SeBase4  72
  120. #define L_Base4  (1+SeBase4)
  121.  
  122. #define SeBase   288
  123. #define L_Base   (1+SeBase)
  124. #define S_DEFAULT S_Base  /* default to base */
  125.  
  126.  
  127. #define VERS      40   /* current version */
  128. #define VLINES    32 /* number of lines to pull in at once for virt memory */
  129.  
  130.  
  131. enum ERRORS { E_NONE,E_READ,E_WRITE,E_INTERN,E_ARG,E_OPT,E_MEM,E_HUFF,
  132.        E_SEQ,E_SEQ1,E_SEQ2,E_SEQ3,E_SEQ4,E_SEQ5,E_SEQ6,E_SEQ7,E_POS,
  133.        E_IMP,E_COOL,E_OVD,E_SCR,E_NCDS,E_ABT };
  134.  
  135. enum TURNS  { T_NONE,T_RIGHT,T_LEFT };
  136.  
  137. enum SIZES  { S_UNSPEC,S_Base16,S_Base4,S_Base,S_4Base,S_16Base,
  138.     S_4BaseHC, S_Over,   };
  139.  
  140. /* Default taken when no size parameter given */
  141.  
  142.  
  143. char *lumfn="OpcdLuma.tmp"; /* filenames for working files */
  144. char *c1fn= "OpcdChr1.tmp";
  145. char *c2fn= "OpcdChr2.tmp";
  146.  
  147. struct ph1 /* the header for the Photo CD file */
  148.  {char id1[8];
  149.   char ww1[14];
  150.   char id2[20];
  151.   char id3[4*16+4];
  152.   short ww2;
  153.   char id4[20];
  154.   char ww3[2*16+1];
  155.   char id5[4*16];
  156.   char idx[11*16];
  157.  } ;
  158.  
  159.  
  160. struct ifhdr{ /* structure header for header */
  161.     ULONG type; /* should be OPif */
  162.     ULONG plane;/* should be LUMA, CHR1, or CHR2 */
  163.     USHORT width; /* typ 1536 */
  164.     USHORT height;/* typ 1024 */
  165.     USHORT vers;
  166.     USHORT misc; }; 
  167.     
  168. struct ifhdr ih={ 0x4F506966,0x4B554C41,1536,1024,40,0}; /* default */    
  169. struct _implane
  170.  {dim  mwidth,mheight, iwidth,iheight;
  171.   byte *im;
  172.  };
  173. typedef struct _implane implane;
  174.  
  175. /* PROTOTYPES */
  176. void   getout(void), cleanup(enum ERRORS);
  177. void   telltime(char *, unsigned int *);
  178. int Display_Mode_Check(void);
  179. int DoOpal(int,int, char *fname),VirtOpal(int,char *);
  180. int GetNextPic(int,int);
  181. int TurnOpal( struct OpalScreen *, UBYTE **, int,int,int,int,int);
  182. struct OpalScreen *OpenOpal(void);
  183. static void planealloc(implane *,dim,dim);
  184.  
  185. static void interpolate(implane *);
  186. static void ycctorgb(dim,dim, implane *,implane *,implane *);
  187. static void readhqt(dim,dim,dim);
  188. static void readhqtsub(struct pcdhqt *source,struct myhqt *ziel,int *anzahl);
  189.  
  190.  
  191. static void decompress(dim,dim,implane *,implane *, implane *);
  192. static void clear(implane *,int);
  193. static void druckeid(void );
  194. static void sharpit(implane *);
  195. int storeplane(implane *,char *); /* save it */
  196. void planefree(implane *); /* free contents of a plane */
  197. enum ERRORS readplain(dim,dim,implane *,implane *,implane*);
  198.  
  199. /* Global Variables */
  200. struct IntuitionBase *IntuitionBase;
  201. struct GfxBase *GfxBase;
  202. struct OpalBase *OpalBase;
  203. struct OpalScreen *OScrn;
  204. struct WBArg *WBArg;
  205. BOOL FromWB;
  206.  
  207. __far UBYTE *Button = (UBYTE *)0xbfe001;    /* Nasty */
  208. __far UWORD *RButton= (UWORD *)0xdff016; /* read right button */
  209.  
  210. __far extern struct Custom custom; /* for registers */
  211.  
  212.  
  213.         /* bit 10, use dff016 for right */
  214. #define RIGHT   custom.joy1dat & 2
  215. #define LEFT    custom.joy1dat & 0x200
  216. #define UP     ( custom.joy1dat & 1 )    
  217. #define DOWN   ( custom.joy1dat & 0x100) 
  218. #define FIRE    (*Button & 0x80)
  219.      
  220. static FILE *fin=0,*fout=0;
  221. static char *pcdname=0,*ppmname=0;
  222. static char nbuf[100];
  223. static byte sbuffer[SECSIZE]; /* Increase, allow for reading 2 sectors */
  224. static byte sbufaux[SECSIZE];
  225. static byte lumadump[3100]; /* for null char for mode 6 */
  226.  
  227. static int do_sharp,backdrop,crop,virt;
  228. static int init;
  229.  
  230. implane Luma, Chroma1,Chroma2,C1t,C2t; /* make them global */
  231. dim w,h;
  232. static int version,cropx,cropw,cropy,croph,jpeg; /* coords for cropping */
  233. int pstart;
  234. unsigned int clock1[2],clock2[2]; /* for timer */
  235.  enum TURNS turn=T_NONE;
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242. /* Using preprocessor for inline-procs */
  243. #ifdef DEBUG
  244. #define SEEK(x) { if (fseek(fin,((x) * SECSIZE),0)) cleanup(E_READ);\
  245.                   fprintf(stderr,"S-Position %x\n",ftell(fin)); }
  246. #else
  247. #define SEEK(x) { if (fseek(fin,((x) * SECSIZE),0)) cleanup(E_READ);}
  248. #endif
  249.  
  250.  
  251. #define SKIP(n)  { if (fseek(fin,(n),1)) cleanup(E_READ);}
  252. #define SKIPr(n) { if (fseek(fin,(n),1)) return(E_READ);}
  253.  
  254. #define READBUF   fread(sbuffer,sizeof(sbuffer),1,fin)
  255. #define READ2BUF  fread(sbuffer,sizeof(sbuffer),2,fin) /* allow for 2 sectors or 4K */
  256.  
  257. #define TRIF(x,u,o,a,b,c) ((x)<(u)? (a) : ( (x)>(o)?(c):(b)  ))
  258. #define NORM(x) x=TRIF(x,0,255,0,x,255)
  259.  
  260. void getout()
  261. {
  262.     cleanup(E_ABT);
  263. } /* just to get out, this is the ^C trap */    
  264.  
  265.  
  266. void cleanup(e)  /* leave and display why */
  267. enum ERRORS e;
  268. {
  269.    switch(e)
  270.    {case E_NONE:   return;
  271.     case E_IMP:    fprintf(stderr,"Sorry, Not yet implemented.\n"); break;
  272.     case E_READ:   fprintf(stderr,"Error while reading.\n"); break;
  273.     case E_WRITE:  fprintf(stderr,"Error while writing.\n"); break;
  274.     case E_INTERN: fprintf(stderr,"Internal error.\n"); break;
  275.     case E_ARG:    fprintf(stderr,"Arguments !\n"); 
  276.                    fprintf(stderr,"OpalPCD Access for Amiga V. %d \n",VERS);
  277.                    fprintf(stderr,"Usage: opalpcd [options] pcd-file [IFF24file]\n");
  278.                    fprintf(stderr,"Opts:\n");
  279.                    fprintf(stderr,"     -i Give some (buggy) informations from fileheader\n");
  280.                    fprintf(stderr,"     -s Apply simple sharpness-operator on the Luma-channel\n");
  281.                    fprintf(stderr,"     -d Show differential picture only \n");
  282.                    fprintf(stderr,"     -r Rotate clockwise for portraits\n");
  283.                    fprintf(stderr,"     -l Rotate counter-clockwise for portraits\n");
  284.                    fprintf(stderr,"     -a Enable AutoSync for Opal Display  \n");
  285.                    fprintf(stderr,"     -p Presentation SLideShow all Images in cd0:\n");
  286.                    fprintf(stderr,"     -b To place image as backdrop upon exit \n"); 
  287.                    fprintf(stderr,"     -c x y [w] [h] crop output image.  \n");
  288.                    fprintf(stderr,"        where x,y =coords of upper left. w&h are size\n");
  289.                    fprintf(stderr,"     -j [quality] Save in Jpeg instead of IFF24  \n"); 
  290.                    fprintf(stderr,"     -v virtual mem. Uses H Drive Modes 4&up only  \n"); 
  291.  
  292.  
  293.                    fprintf(stderr,"     -O Extract thumbnails from Overview file\n");
  294.                    fprintf(stderr,"     -1 Extract  128x192  from Image file\n");
  295.                    fprintf(stderr,"     -2 Extract  256x384  from Image file\n");
  296.                    fprintf(stderr,"     -3 Extract  512x768  from Image file\n");
  297.                    fprintf(stderr,"     -4 Extract 1024x1536 from Image file\n");
  298.                    fprintf(stderr,"     -5 Extract 2048x3072 from Image file\n");
  299.                    fprintf(stderr,"     -6 Extract 1024X1536 Enhanced Chroma\n");
  300.                    break;
  301.     case E_OPT:    fprintf(stderr,"These Options are not allowed together.\n");break;
  302.     case E_MEM:    fprintf(stderr,"Not enough memory !\n"); break;
  303.     case E_HUFF:   fprintf(stderr,"Error in Huffman-Code-Table\n"); break;
  304.     case E_SEQ:    fprintf(stderr,"Error in Huffman-Sequence\n"); break;
  305.     case E_SEQ1:    fprintf(stderr,"Error1 in Huffman-Seque nce\n"); break;
  306.     case E_SEQ2:    fprintf(stderr,"Error2 in Huffman-Sequence\n"); break;
  307.     case E_SEQ3:    fprintf(stderr,"Error3 in Huffman-Sequence\n"); break;
  308.     case E_SEQ4:    fprintf(stderr,"Error4 in Huffman-Sequence\n"); break;
  309.     case E_SEQ5:    fprintf(stderr,"Error5 in Huffman-Sequence\n"); break;
  310.     case E_SEQ6:    fprintf(stderr,"Error6 in Huffman-Sequence\n"); break;
  311.     case E_SEQ7:    fprintf(stderr,"Error7 in Huffman-Sequence\n"); break;
  312.     case E_POS:    fprintf(stderr,"Error in file-position\n"); break;
  313.     case E_COOL:    fprintf(stderr,"Cannot opan opal.library \n"); break;
  314.      case E_OVD:    fprintf(stderr,"Opalvision error      \n"); break;
  315.      case E_SCR:    fprintf(stderr,"You need a 15KHZ scan rate(genlockable) screen  \n"); break;
  316.     case E_NCDS:     fprintf(stderr," Slide Show available in Base/4 and Base Only \n"); break;
  317.      case E_ABT:    fprintf(stderr," User Aborted with CTRL-C \n");
  318.     default:       fprintf(stderr,"Unknown error %d ???\n",e);break;
  319.    }
  320.   if(fin) fclose(fin); /* close files */
  321.   if(fout) fclose(fout);
  322.   if (OpalBase!=NULL) /* if we did play with OpalVision, lets fix things */
  323.         {   AmigaPriority();
  324.             if (OScrn) FreeScreen24 (OScrn); /* oops, forgot */
  325.              CloseScreen24 ();
  326.           CloseLibrary ((struct Library *)OpalBase);
  327.    }
  328.  
  329.   exit(e); /* return the error */
  330. }
  331.  
  332.  
  333. static void planealloc(p,width,height)
  334.   implane *p;
  335.   dim width,height;
  336.  {
  337.   p->iwidth=p->iheight=0;
  338.   p->mwidth=width;
  339.   p->mheight=height;
  340.     /* this is level II and freed by c startup, we should fix later */
  341.   p->im = ( byte * ) malloc  (width*height);/* we know a byte is 1! */
  342.   if(!(p->im)) cleanup(E_MEM);
  343.  }
  344.  
  345. void planefree(implane *p) /* simply free the plane added 5/6/93 */
  346. {
  347.  if ( p->im) free(p->im); /* that's it! */
  348.     
  349. }    
  350.  
  351.  
  352.  
  353. main(argc,argv)  /* MAIN  */
  354. int argc;
  355. char **argv;
  356. {int i,bildnr;
  357. char *opt;
  358. int do_auto,cd_offset,do_info,do_diff,do_overskip,do_slide;
  359. int cccnt=0,Err,a,orun=0;
  360. enum SIZES size=S_UNSPEC;
  361. UBYTE   *rgbps[3]; 
  362.     enum ERRORS eret;
  363.     pstart=1; /* normally start at 1 */
  364.     ih.vers=VERS; /* current version */ 
  365.     do_info=do_auto=do_diff=do_overskip=do_sharp=0; 
  366.     backdrop=do_slide=crop=jpeg=virt=0; /* default to 0 */
  367.     Luma.im=Chroma1.im=Chroma2.im = NULL;
  368.     ASKIP;
  369.     init=0;
  370.     onbreak(getout); /* try to set a ctrl c trap */
  371.         /* parse input line */
  372.     cropx=cropy=-1; /* default meaning not set */
  373.     cropw=DISP_W;  croph=DISP_H; /* default to one full screen */
  374.     while((argc>0) && (**argv=='-')) {
  375.          opt= (*argv)+1;
  376.          ASKIP
  377.          
  378.       /* don't screw with anything between the while and this comment */
  379.          
  380.       if(!strcmp(opt,"c")) /* crop coordinates  */
  381.             { /* now fetch coords */
  382.                crop=255;
  383.                if( isdigit( **argv) && (argc >0)) { /* see if following is a # */
  384.                    cropx=atoi(*argv); cccnt++;
  385.                    ASKIP
  386.                    if(isdigit(**argv) && argc ){ /* look for cropy */
  387.                         cropy=atoi(*argv); cccnt++; 
  388.                         ASKIP
  389.                         if(isdigit(**argv) && argc ){ /* look for cropw */
  390.                             cropw=atoi(*argv); cccnt++;
  391.                             ASKIP
  392.                             if(isdigit(**argv)&&argc ){ /* look for croph */
  393.                                 croph=atoi(*argv); cccnt++; 
  394.                                  ASKIP;
  395.          
  396.                                 /* we got all four if we got here */
  397.                             }    
  398.                             else {  cropw=DISP_W; } /* cant use w w/o h*/   
  399.                         }
  400.                             
  401.                    }
  402.                    else {  cropx= -1; }
  403.                }
  404.                 /* couldnt get cropx */ 
  405.            printf( "cropping left = %d top = %d width = %d height =%d\n",cropx,cropy,cropw,croph);
  406.                      continue; 
  407.             }
  408.  
  409.  
  410.         if(!strcmp(opt,"j")) /* select jpeg file mode  */
  411.             {
  412.                if (isdigit ( **argv) && (**argv != '-')&&(argc>0)) {
  413.                          /* look for quality factor */
  414.                    jpeg=atoi(*argv);
  415.                    ASKIP
  416.                 }
  417.                else { jpeg =  84;   } /* assume 84 if not spec */    
  418.                if (jpeg <1 )  jpeg=1;
  419.                if (jpeg >100) jpeg=100; 
  420.                 
  421.                continue;                       
  422.             }
  423.    /*     printf("past my options %d  \n",argc);  */
  424.  
  425.         if(!strcmp(opt,"a")) /* slide show mode */
  426.             {if (!do_auto ) do_auto=255;
  427.             else cleanup(E_ARG);
  428.             continue;
  429.             }
  430.  
  431.  
  432.         if(!strcmp(opt,"p")) /* slide show mode */
  433.             {if (!do_slide ) do_slide=255;
  434.             else cleanup(E_ARG);
  435.             continue;
  436.             }
  437.        if(!strcmp(opt,"v")) /* Virtual memory mode, size 4 and up please! */
  438.             {if (!virt  ) virt=255;
  439.             else cleanup(E_ARG);
  440.             continue;
  441.             }
  442.  
  443.  
  444.  
  445.         if(!strcmp(opt,"r"))
  446.             {if (turn == T_NONE) turn=T_RIGHT;
  447.             else cleanup(E_ARG);
  448.             continue;
  449.  
  450.             }
  451.  
  452.         if(!strcmp(opt,"l"))
  453.             {if (turn == T_NONE) turn=T_LEFT;
  454.             else cleanup(E_ARG);
  455.             continue;
  456.             }
  457.  
  458.         if(!strcmp(opt,"i")) 
  459.             { if (!do_info) do_info=1;
  460.             else cleanup(E_ARG);
  461.             continue;
  462.             }
  463.  
  464.  
  465.         if(!strcmp(opt,"d")) 
  466.             { if (!do_diff) do_diff=1;
  467.             else cleanup(E_ARG);
  468.             continue;
  469.             }
  470.           if(!strcmp(opt,"b")) 
  471.             { if (!backdrop) backdrop=1;
  472.             else cleanup(E_ARG);
  473.             continue;
  474.             }
  475.  
  476.         if(!strcmp(opt,"s")) 
  477.             { if (!do_sharp) do_sharp=1;
  478.             else cleanup(E_ARG);
  479.             continue;
  480.             }
  481.  
  482.  
  483.         if(!strcmp(opt,"x")) 
  484.             { if (!do_overskip) do_overskip=1;
  485.             else cleanup(E_ARG);
  486.             continue;
  487.             }
  488.  
  489.  
  490.  
  491.    /* get desired size */
  492.         if((!strcmp(opt,"Base/16")) || (!strcmp(opt,"1"))  || (!strcmp(opt,"128x192")))
  493.           {  if (size == S_UNSPEC) size = S_Base16;
  494.             else cleanup(E_ARG);
  495.             continue;
  496.         }
  497.         if((!strcmp(opt,"Base/4" )) || (!strcmp(opt,"2"))  || (!strcmp(opt,"256x384")))
  498.             { if (size == S_UNSPEC) size = S_Base4;
  499.             else cleanup(E_ARG);
  500.             continue;
  501.         }
  502.         if((!strcmp(opt,"Base"   )) || (!strcmp(opt,"3"))  || (!strcmp(opt,"512x768")))
  503.             { if (size == S_UNSPEC) size = S_Base;
  504.             else cleanup(E_ARG);
  505.             continue;
  506.         }
  507.         if((!strcmp(opt,"4Base"  )) || (!strcmp(opt,"4"))  || (!strcmp(opt,"1024x1536")))
  508.             { if (size == S_UNSPEC) size = S_4Base;
  509.             else cleanup(E_ARG);
  510.              continue;
  511.         }
  512.         if((!strcmp(opt,"16Base" )) || (!strcmp(opt,"5"))  || (!strcmp(opt,"2048x3072")))
  513.         { if (size == S_UNSPEC) size = S_16Base;
  514.             else cleanup(E_ARG);
  515.             continue;
  516.             }
  517.        if( (!strcmp(opt,"4BC" )) || (!strcmp(opt,"6")) )
  518.         { if (size == S_UNSPEC) size = S_4BaseHC;
  519.             else cleanup(E_ARG);
  520.             continue;
  521.             }
  522.  
  523.  
  524.         if((!strcmp(opt,"Overview" )) || (!strcmp(opt,"0"))  || (!strcmp(opt,"O")))
  525.             { if (size == S_UNSPEC) size = S_Over;
  526.             else cleanup(E_ARG);
  527.             continue;
  528.             }
  529.  
  530.         fprintf(stderr,"Unknown option: -%s\n",opt);
  531.             cleanup(E_ARG);
  532.     }
  533.  
  534.  
  535.  /*  printf( "loop completed \n");*/
  536.  
  537.   if(size==S_UNSPEC) size=S_DEFAULT;
  538.  
  539.   if((argc<1) && !(do_slide)) cleanup(E_ARG); /* forgive lack of name if slide */
  540.   pcdname= *argv; 
  541.     ASKIP;
  542.  
  543.   if(argc>0) 
  544.    {ppmname= *argv;
  545.     ASKIP;
  546.    }
  547.   if ( isdigit(*pcdname) &&  isdigit ( *(pcdname+1) ) && (strlen(pcdname)==2))
  548.      { /*two digit number, use as easy file name  */
  549.          pstart= (*pcdname - 48)*10 ;
  550.         pstart+=( *(pcdname+1) -48);
  551.         printf("starting at %d \n",pstart);
  552.         strcpy(nbuf,"CD0:PHOTO_CD/IMAGES/IMG00"); /* build name */
  553.         strcat(nbuf,pcdname);
  554.         strcat(nbuf,".PCD");
  555.         pcdname=nbuf; /* transfer pointer */
  556.         if (size == S_Over) pcdname ="CD0:PHOTO_CD/OVERVIEW.PCD";
  557.         /* for an overview, use this file 4-15-93 */
  558.             }   
  559.   if(argc>3) cleanup(E_ARG);
  560. /*  if((size==S_Over) && (!ppmname)) cleanup(E_ARG); */
  561.   if(do_info && (size==S_Over)) cleanup(E_OPT);
  562.   if(do_diff && (size != S_4Base) && (size != S_16Base)&& (size != S_4BaseHC)) cleanup(E_OPT);
  563.   if(do_overskip) cleanup(E_IMP);
  564.   if(do_overskip && (size != S_Base4) && (size != S_Base16)) cleanup(E_OPT);
  565.   if(do_slide) { /* for auto */
  566.        
  567.       ppmname=NULL; /* we wont save file */
  568.       if(!(pcdname)) 
  569.             pcdname="CD0:PHOTO_CD/IMAGES/IMG0001.PCD"; 
  570.             /* start at beginning if not spec  */
  571.       if (size > S_Base) {
  572.             printf( "can't slideshow above base res \n");
  573.             cleanup(E_ARG);    }      
  574.    }
  575. /*  printf( " infile %s jpeg %d slide %d argc %d \n",pcdname,jpeg,do_slide,argc);
  576. */
  577. #ifdef DEBUG
  578. fprintf(stderr,"Turn %d  Size %d Pcd %s  ppm %s\n",turn,size,pcdname,ppmname);
  579. #endif
  580.  
  581.   if(!(fin=fopen(pcdname,"r"))) cleanup(E_READ);
  582.   if(do_info) druckeid(); /* show ID code */
  583.     OpalBase = (struct OpalBase *) OpenLibrary ("opal.library",0L);
  584.     if (OpalBase==0L) /* opal opal library */
  585.         cleanup (E_COOL);
  586.     OScrn = NULL;
  587.   i=timer(clock1); /* get clock */
  588.  
  589.   switch(size) /* perform the operation based on size */
  590.    {
  591.     case S_Base16: w=BaseW/4;
  592.                    h=BaseH/4;
  593.                    if (do_slide) cleanup( E_NCDS);
  594.  
  595.                    planealloc(&Luma   ,w,h);
  596.                    planealloc(&Chroma1,w,h);
  597.                    planealloc(&Chroma2,w,h);
  598.  
  599.                    SEEK(L_Head+1);
  600.                    cleanup(readplain(w,h,&Luma,&Chroma1,&Chroma2));
  601.  
  602.                    interpolate(&Chroma1);
  603.                    interpolate(&Chroma2);
  604.  
  605.                    ycctorgb(w,h,&Luma,&Chroma1,&Chroma2);
  606.               /* Now Luma holds red, Chroma1 hold green, Chroma2 holds blue */
  607.  
  608.              
  609.               /*     writepicture(w,h,&Luma,&Chroma1,&Chroma2,turn);*/
  610.                    OpenOpal();
  611.                    DoOpal(do_auto,do_slide,ppmname);
  612.                    break;
  613.  
  614.     case S_Base4:  w=BaseW/2;
  615.                    h=BaseH/2;
  616.                    planealloc(&Luma   ,w,h);
  617.                    planealloc(&Chroma1,w,h);
  618.                    planealloc(&Chroma2,w,h);
  619.  
  620.                    SEEK(L_Head+L_Base16+1);
  621.                    cleanup(readplain(w,h,&Luma,&Chroma1,&Chroma2));
  622.  
  623.                    interpolate(&Chroma1);
  624.                    interpolate(&Chroma2);
  625.  
  626.                    ycctorgb(w,h,&Luma,&Chroma1,&Chroma2);
  627.                    /* Now Luma holds red, Chroma1 hold green, Chroma2 holds blue */
  628.  
  629.                    OpenOpal();
  630.                    DoOpal(do_auto,do_slide,ppmname);
  631.                    break;
  632.  
  633.     case S_Base:   w=BaseW;
  634.                    h=BaseH;
  635.                  
  636.                    planealloc(&Luma   ,w,h);
  637.                    planealloc(&Chroma1,w,h);
  638.                    planealloc(&Chroma2,w,h);
  639.                          if (!OpenOpal()) cleanup(E_OVD);
  640.                    
  641.                    SEEK(L_Head+L_Base16+L_Base4+1);
  642.                    cleanup(readplain(w,h,&Luma,&Chroma1,&Chroma2));
  643.                    interpolate(&Chroma1);
  644.                    interpolate(&Chroma2);
  645.                    ycctorgb(w,h,&Luma,&Chroma1,&Chroma2);
  646.                    /* Now Luma holds red, Chroma1 hold green, Chroma2 holds blue */
  647.                    DoOpal( do_auto,do_slide,ppmname); /* do all the nice OpalVision stuff */
  648.                    break;
  649.     case S_4BaseHC:
  650.     case S_4Base:  w=BaseW*2;
  651.                    h=BaseH*2;
  652.                     if (do_slide) cleanup( E_NCDS);
  653.                    planealloc(&Luma,w,h);  /* thats almost 5 meg! */
  654.                    planealloc(&Chroma1,w,h);
  655.                    planealloc(&Chroma2,w,h);  
  656.                    if ( !virt){ /* open it here if NOT virtual mem */
  657.                                  
  658.                       if (!OpenOpal()) {
  659.                           printf("Can't open Opal Screen. Try a smaller area \n");
  660.                           cleanup(E_OVD);       } 
  661.                     }
  662.                    SEEK(L_Head+L_Base16+L_Base4+1);
  663.                    /* THIS IS ONLY THE SAME AS MODE 3! */
  664.                    cleanup(readplain(w/2,h/2,&Luma,&Chroma1,&Chroma2));
  665.  
  666.                    interpolate(&Luma);
  667.                    interpolate(&Chroma1);
  668.                    interpolate(&Chroma1);
  669.                    interpolate(&Chroma2);
  670.                    interpolate(&Chroma2);  
  671.  
  672.                    if(do_diff) {clear(&Luma,128);clear(&Chroma1,156);clear(&Chroma2,137);}
  673.                         /* above only clears */
  674.         
  675.                    cd_offset = L_Head + L_Base16 + L_Base4 + L_Base ;
  676.  
  677.  
  678.                    SEEK(cd_offset + 4);     readhqt(w,h,1); 
  679.  
  680.                    SEEK(cd_offset + 5);  
  681.                    decompress(w,h,&Luma,0,0); 
  682.               /* add full LUMA res */
  683.                    if (size== S_4BaseHC) { /* we are trying to fill colors*/
  684.                         cd_offset=ftell(fin);
  685.                         if(cd_offset % SECSIZE) cleanup(E_POS);
  686.                         cd_offset/=SECSIZE;
  687.                         SEEK(cd_offset+12);
  688.                         readhqt(w*2,h*2,3);
  689.                         printf(" gonna decomp the chroma now\n");
  690.                         SEEK(cd_offset+14);
  691.                         decompress(w*2,h*2,0,&Chroma1,&Chroma2);
  692.  
  693.                         /* try adding full chroma from highest sampling */
  694.                    }     
  695.                    if (virt) { /* do this if using virtual mem */
  696.                         printf("Virtual memory mode selected, now saving \n");
  697.                         ih.width=w; ih.height=h;
  698.                         i=storeplane(&Luma,lumfn); /* store Luma plane*/
  699.  
  700.                         planefree(&Luma); /* free it up */
  701.                         if (i) { printf("Error %d storing intermediate file, too little disk space? \n",i);
  702.                                 cleanup(E_WRITE); }
  703.                         i=storeplane(&Chroma1,c1fn); 
  704.                         planefree(&Chroma1);
  705.                         i=storeplane(&Chroma2,c2fn); 
  706.                         planefree(&Chroma2);                         
  707.                         if (i) { printf("Error %d storing intermediate file, too little disk space? \n",i);
  708.                                 cleanup(E_WRITE); }
  709.                         if (!OpenOpal()) {
  710.                           printf("Can't open Opal Screen.  Try a smaller area \n");
  711.                           cleanup(E_OVD);
  712.                         } 
  713.                         VirtOpal(do_auto,ppmname);
  714.                     }
  715.                    else { ycctorgb(w,h,&Luma,&Chroma1,&Chroma2);  
  716.                         /* normal mode, do all in one swell foop.  Needs 12M fast*/
  717.                         telltime("Time to Decode Picture:",clock1);
  718.                         DoOpal( do_auto,do_slide,ppmname); /* try disp some */
  719.                    }
  720.                    break;
  721.  
  722.     case S_16Base: w=BaseW*4;
  723.                    h=BaseH*4;
  724.                    if (do_slide) cleanup( E_NCDS);
  725.                    planealloc(&Luma,w,h);/* full luma no matter what */
  726.                    SEEK(L_Head+L_Base16+L_Base4+1);
  727.  
  728.                    if (virt){ /* Virt Mem.  Just alloc enuf chroma to read PCD!*/
  729.                         planealloc(&C1t,w/8,h/8);/* just get the data for now */
  730.                         planealloc(&C2t,w/8,h/8);/* theyre only 98K each */
  731.                         cleanup(readplain(w/4,h/4,&Luma,&C1t,&C2t));
  732.                         }
  733.                    else {planealloc(&Chroma1,w,h);/* normal, got 20-40Meg??*/
  734.                          planealloc(&Chroma2,w,h); 
  735.                          OpenOpal(); 
  736.                          cleanup(readplain(w/4,h/4,&Luma,&Chroma1,&Chroma2));
  737.                          interpolate(&Chroma1);
  738.                          interpolate(&Chroma1);
  739.                          interpolate(&Chroma2);
  740.                          interpolate(&Chroma2); /* expand chroma */
  741.                                          }
  742.                                   
  743.                    interpolate(&Luma); /* expand luma to 1536x1024 */
  744.                   
  745.                    cd_offset = L_Head + L_Base16 + L_Base4 + L_Base ;
  746.                    SEEK(cd_offset + 4);             
  747.                    readhqt(w/2,h/2,1);
  748.                    SEEK(cd_offset + 5);
  749.                    decompress(w/2,h/2,&Luma,0,0); /* decomp luma to 1536x1024*/
  750.                    interpolate(&Luma); /* spread Luma to 3072x2048 */
  751.                    cd_offset=ftell(fin);
  752.                    if(cd_offset % SECSIZE) cleanup(E_POS);
  753.                    cd_offset/=SECSIZE;
  754.  
  755.                    SEEK(cd_offset+12);
  756.                    readhqt(w,h,3);
  757.                    if(do_diff) {clear(&Luma,128);clear(&Chroma1,156);clear(&Chroma2,137);}
  758.                    SEEK(cd_offset+14); /* we are in position for final decomp */
  759.                    if (virt) { /* Again, do this in virtual mode */
  760.                         /* takes about 10 Meg of HD space */
  761.                         ih.width=w; ih.height=h; /* store size */
  762.                          printf("Virtual memory selected, saving Mode 5 Luma \n");
  763.  
  764.                         decompress(w,h,&Luma,&Chroma1,&Chroma2);/* decomp the final Luma */
  765.                  /* CODE MOVED TO DECOMPRESS TO STORE LUMA AND SETUP CHROMA PLANES */
  766.                  /* THIS BECAUSE DECOMPRESS IS NOT TOO REENTRANT AND I DONT WANT TO F*** WITH IT*/
  767.                  
  768.                        /* at this point, we should have two 1536x1024 chroma planes
  769.                         unless we got a huffman error, etc */
  770.                         ih.width=w/2; ih.height=h/2; /* chroma planes 1/4 size*/
  771.                   
  772.                         i=storeplane(&Chroma1,c1fn);  
  773.                         planefree(&Chroma1);/* store and free them */
  774.                         i=storeplane(&Chroma2,c2fn); 
  775.                         planefree(&Chroma2);                         
  776.                         if (i) { printf("Error %d storing intermediate file, too little disk space? \n",i);
  777.                                 cleanup(E_WRITE); }
  778.                         if (!OpenOpal()) {
  779.                           printf("Can't open Opal Screen.  Try a smaller area \n");
  780.                           cleanup(E_OVD);
  781.                         } 
  782.                      /* NOTE: WE WILL DO FINAL INTERPOLATION OF CHROMA WHEN
  783.                         WE LOAD IT BACK IN.  This saves 9M HD+Xfer time */   
  784.                         VirtOpal(do_auto,ppmname);
  785.                    }
  786.                    else { /* 'Normal' Mode, that is, if you own Samsung Memory division */
  787.                         decompress(w,h,&Luma,0,0);
  788.                         interpolate(&Chroma1);
  789.                         interpolate(&Chroma2); 
  790.                     
  791.                         ycctorgb(w,h,&Luma,&Chroma1,&Chroma2);  
  792.                         DoOpal(do_auto,0,ppmname); /* display what we can */
  793.  
  794.                         }
  795.                    /* Now Luma holds red, Chroma1 hold green, Chroma2 holds blue */
  796.                    break;
  797.  
  798.     case S_Over: /* we are going to render some small images */
  799.        w=BaseW;
  800.        h=BaseH; /* use a full size screen for now */
  801.        
  802.        planealloc(&Luma   ,w/4,h/4); /* allocate for tiny images */
  803.        planealloc(&Chroma1,w/4,h/4);
  804.        planealloc(&Chroma2,w/4,h/4);
  805.        if( !(Chroma2.im) ) cleanup(E_MEM);
  806.        rgbps[0]=Luma.im;
  807.        rgbps[1]=Chroma1.im; /* copy pointers */
  808.        rgbps[2]=Chroma2.im;  
  809.        if (!( OpenOpal())) cleanup(E_OVD);
  810.        OScrn->Pen_R=OScrn->Pen_G=0;
  811.        OScrn->Pen_B=100; /* blue background */
  812.       for(orun=0; orun <8 && !feof(fin); orun++){ /* loop each page (16 pix) */
  813.        SetScreen24(OScrn); /* clear and install bkgrnd */
  814.        for(bildnr=orun<<4;!feof(fin) && (bildnr< (orun+1)<<4);bildnr++){ /* ea pic*/
  815.                SEEK(5+SeBase16*bildnr);
  816.     
  817.                eret=readplain(w/4,h/4,&Luma,&Chroma1,&Chroma2);
  818.                        if(eret==E_READ) break;
  819.                        cleanup(eret);
  820.  
  821.                interpolate(&Chroma1);
  822.                interpolate(&Chroma2);
  823.     
  824.                ycctorgb(w/4,h/4,&Luma,&Chroma1,&Chroma2); 
  825.                /* Now Luma holds red, Chroma1 hold green, Chroma2 holds blue */
  826.                RGBtoOV(OScrn,rgbps,(bildnr&3)*190,((bildnr>>2)&3)*120,192,128);
  827.                /* render each of 16 in */
  828.  
  829.         }   
  830.            AutoSync24(do_auto);
  831.          Err = (long)LowMemUpdate24 (OScrn,0);
  832.         if ((Err>OL_ERR_MAXERR) && (!(OScrn->Flags&ILACE24)))
  833.         {   AutoSync24 (do_auto);
  834.           /*  Err = (long)LowMemUpdate24 (OScrn,6); */
  835.         } 
  836.        /* end of main loop.  If we save img, save last image */ 
  837.          while ( ( *Button &0x040) &&(*RButton & RBMASK) ){ /* button for single show */
  838.             Delay(10); } /* if no button down wait */
  839.         
  840.          if   (!(*RButton & RBMASK)){ /* right pushed */
  841.             
  842.              /* next page and continue */
  843.             if ( feof(fin) ){ orun=-1; /* if we hit end of pix, start anew */
  844.                 rewind(fin); /* set position back to start */
  845.                 Delay(5); }
  846.          }       
  847.          else orun=20; /* put loop var high to exit, was left mouse button */ 
  848.              
  849.        } /* end of running loop, past here were done */ 
  850.         
  851.         if ( (OScrn) && (ppmname) ){ /* we can save file */
  852.             if (jpeg)
  853.               a=SaveJPEG24(OScrn,ppmname,NULL, jpeg);
  854.             else  
  855.               a=SaveIFF24(OScrn,ppmname, NULL,NULL); 
  856.             if (a) printf( "iff save error # %d couldn't save picture\n",a);
  857.             else printf( "file saved as %s \n",ppmname);
  858.         }  
  859.      
  860.                if ( backdrop){ /* we want to leave image as backdrop */
  861.             AmigaPriority ();
  862.             DualDisplay24 ();
  863.             Delay (2L);
  864.             LatchDisplay24 (TRUE);
  865.             Delay (2L);
  866.     
  867.         }                    
  868.          FreeScreen24 (OScrn); /* clean up here */
  869.         CloseScreen24(); 
  870.         return(0);    
  871.              
  872.       break;
  873.      
  874.      default: cleanup(E_INTERN); 
  875.    }
  876. /* WE USE LEVEL 2 FILE&MEM HANDLING, IF WE FORGET TO FREE OR CLOSE, NO HARM DONE*/
  877.     exit(0); /* exit normal */
  878. }
  879.  
  880. #undef ASKIP
  881.  
  882.  
  883.  
  884. struct OpalScreen *OpenOpal() /* display and save OV */
  885.                 /* This just appropriats and opens the Opal Screen */
  886. {
  887. long scm;
  888. int dw,dh;
  889.  
  890.     scm= OVERSCAN24;
  891.    
  892.    if (!Display_Mode_Check()) 
  893.         cleanup( E_SCR); /* check for 15KHZ res */
  894.       dw= DISP_W/2; dh=DISP_H/2; 
  895.       if ( w> 400) {
  896.         scm |= ILACE24 | HIRES24; /* if base & up do hires lace */
  897.         dw=DISP_W; dh=DISP_H;
  898.         if ( !crop) cropx=cropy=0;
  899.       }  
  900.       else {
  901.         cropx= (dw-w+2)/2; /* center picture tiny res no crop possible */
  902.         cropy= (dh-h+2)/2;
  903.       }    
  904.       
  905.       if ( !crop ) {
  906.               if (turn){
  907.                 OScrn = CreateScreen24(scm,max(dw,h),max(dh,w)) ; 
  908.                              }  
  909.               else 
  910.                 OScrn = CreateScreen24(scm,max(dw,w),max(dh,h)) ; 
  911.                 /* same size virtual screen */
  912.              }
  913.     else { /* set up for cropping */
  914.         if  ((cropw>w) || (cropw < 32)) cropw=dw; /* limit width */
  915.         if  ((croph>h) || (croph < 20)) croph=dh; /* default to center if bad*/
  916.         if ( (cropx < 0) || (cropy <0 ) || (cropx>w) || (croph>h)  ) {
  917.             /* invalid or unspecified values */
  918.             cropx=(w-cropw)/2; /* center */
  919.             cropy=(h-croph)/2; /* a normal 736x480 is disp if numbers bad */    
  920.         }
  921.         OScrn = CreateScreen24(scm,cropw,croph);
  922.       /* create just for disp to test higher mode */
  923.     }
  924.             
  925.     if ( !OScrn){
  926.         printf( "Can't Alloc Opal Screen, Try a smaller area \n");
  927.          }
  928.         /* create the virtual screen to plop the data in */
  929.     return(OScrn);
  930. } 
  931.  
  932. int VirtOpal(int asy, char *fname) /* fill display and save OV */
  933. { /* virtual memory ONLY size 4&up(1536x1024 or 3072x2048
  934.     May 7, 1993    
  935.     THIS IS USED INSTEAD OF DoOpal and TurnOpal.  It reads back the raw data
  936.     32 lines at a time and does final conversion and puts them in Opal screen */
  937. int a,maxy,nrep,dw,dh,i;
  938. long Err;
  939. register int x,y,yi;
  940. byte *rgbuf[4],*lb1,*lb2,*op1,*np1,*up1,*op2,*np2,*up2; /* pointers into array */
  941. FILE *fpl,*fp1,*fp2; /* pointers to three files */
  942. struct ifhdr  hl,h1,h2; /* header data */
  943.     planealloc(&Luma   ,w,VLINES);/* make some mini Planes to reload parts */
  944.     planealloc(&Chroma1,w,VLINES+4);/* should be 150 or 300K */
  945.     planealloc(&Chroma2,w,VLINES+4);/* a little xtra in chroma for rollover */
  946.     lb1=malloc(w); /* small buffers for shuffling lines in interp */
  947.     lb2=malloc(w); /* each = width for long lines */
  948.     if ( !lb2) cleanup(E_MEM); /* not enuf mem, need only check second one */
  949.     maxy=h;
  950.     if(crop) maxy=cropy+croph+VLINES-1; /* only get what we need but entire sector */
  951.     if (maxy>h) maxy=h; /* but no more than picture */
  952.     nrep = maxy/VLINES; /* number of times we pull in */
  953.     fpl=fopen(lumfn,"r"); /* try to open all our files */
  954.     fp1=fopen(c1fn,"r");
  955.     fp2=fopen(c2fn,"r"); 
  956.     if (!fp1 || !fp2 || !fpl) { /* couldn't open */
  957.         printf(" Unable to open one or more intermediate file(s) \n");
  958.         cleanup(E_READ); }
  959.         
  960.     fread(&hl,16,1,fpl); /* get header data.  we MAY actually use this someday!*/
  961.     fread(&h1,16,1,fp1);
  962.     fread(&h2,16,1,fp2);
  963.     rgbuf[0]=Luma.im; /* set buffer pointer for conversion to to opal*/
  964.     rgbuf[1]=Chroma1.im;
  965.     rgbuf[2]=Chroma2.im;
  966.         
  967.     /* assume the Opal Screen is already made */
  968.     if (!OScrn) cleanup(E_OVD); /* but check to make sure */
  969.     dw= OScrn->Width; /* get these from Opal Screen structure */
  970.     dh= OScrn->Height;
  971.     /* below here updated for each pic, so loop on this ! */
  972.     telltime("Starting file readback. Time so far=",clock1);
  973.     for(i=0;i<nrep;i++) { /* take a 300K hunk of data and move it in */
  974.         fread(Luma.im,w,VLINES,fpl); /* read in a hunk of data,64 lines */
  975.         if ( w>2000) { /* handle chroma differently for Mode 5 */
  976.            if (i==0) { /* first set of lines */ 
  977.                 a=fread(Chroma1.im,w/2,(VLINES/2)+1,fp1); /* one xtra line f/interp */ 
  978.                 a=fread(Chroma2.im,w/2,(VLINES/2)+1,fp2); }
  979.            else {/* WE NEED ONE MORE LINE SO WE CAN INTERPOLATE LINE # VLINES-1!*/
  980.                 memcpy(Chroma1.im,lb1,w/2); /* copy the top line last time is bottom */
  981.                 memcpy(Chroma2.im,lb2,w/2); /* need this for seamless interp */
  982.                 a=fread(Chroma1.im+(w/2),w/2,(VLINES/2),fp1); /* read the rest from HD */ 
  983.                 a=fread(Chroma2.im+(w/2),w/2,(VLINES/2),fp2); /* half width half ht*/
  984.                  }     
  985.            memcpy(lb1,Chroma1.im+((w*VLINES)/4),w/2); /* get raw last line */
  986.            memcpy(lb2,Chroma2.im+((w*VLINES)/4),w/2); /* becomes first line now  */
  987.            if (a< (VLINES/2)-1) cleanup(E_READ); /* we could not read all data */
  988.            yi=(VLINES/2)+1; /*count lines backward starting with extra line */  
  989.            for(y=0;y<((VLINES/2)+1);y++){ /* do our interp, move& stretch lines  */
  990.                 yi--; /* start from bottom near END */
  991.                 op1=Chroma1.im+(( yi+1)*w/2)-1;/* old pointer 1/2 way */
  992.                 np1=Chroma1.im+(yi*w*2)+w-2 ; /* destination pointer */
  993.                 op2=Chroma2.im+(( yi+1)*w/2)-1  ;/* old pointer 1/2 way */
  994.                 np2=Chroma2.im+(yi*w*2)+w-2  ; /* destination pointer */
  995.                     /* go DOWN in x, DOWN in Y. Don't paint ourselfs in a corner */
  996.  
  997.                 *np1=*(np1+1)=*op1; /* set end points equal */
  998.                 *np2=*(np2+1)=*op2; 
  999.                 for(x=1;x<(w/2);x++){/* do this #of times of current width */
  1000.                     op1--; np1-=2; op2--; np2-=2; /* drop old ptr by 1 and new by 2 */
  1001.                     *np1=*op1; *np2=*op2; /* set the even point equal */
  1002.                  /*   *(np1+1)=*op1; *(np2+1)=*op2; */ /* dont interp */
  1003.                     np1[1]=(((short)op1[0])+((short) op1[1]))>>1;  
  1004.                     np2[1]=(((short)op2[0])+((short) op2[1]))>>1; /*
  1005.                         this point and next  point in X direction */
  1006.                 }              /* try sub divede by 2 with >>1 */ 
  1007.            }
  1008.  
  1009.            for(y=0;y<(VLINES+2);y+=2){  /* this reads between the lines */
  1010.                 op1=Chroma1.im + (y*w);/* op=linebelow up=line above*/
  1011.                 np1=op1+w;  up1=np1+w; /* set pointers one finished line apart */
  1012.                 op2=Chroma2.im + (y*w);
  1013.                 np2=op2+w;  up2=np2+w; /* set pointers one finished line apart */
  1014.                 for(x=0;x<w;x++){ /* set odd lines by reading between even lines */
  1015.                     *(np1++)=(((int)*(op1++))+((int)*(up1++)))>>1;
  1016.                     *(np2++)=(((int)*(op2++))+((int)*(up2++)))>>1;
  1017.                     /* the missing lines are the avg of lines above&below*/
  1018.                 }    
  1019.            } /* close for Y loop */
  1020.  
  1021.             
  1022.                               
  1023.         } /* close w>2000 loop */
  1024.         else{ /* for modes 4,6 we have all bytes */    
  1025.             a=fread(Chroma1.im,w,VLINES,fp1);
  1026.             a= fread(Chroma2.im,w,VLINES,fp2); 
  1027.             if (a<VLINES) cleanup(E_READ); /* we could not read all data */
  1028.         }  
  1029.         if ( !(i&7) ) printf("\n"); /* lf every 8 numbers */
  1030.         printf("%d ",i*VLINES);
  1031.  
  1032.         ycctorgb(w,VLINES,&Luma,&Chroma1,&Chroma2); /* convert it to RGB */
  1033.         RGBtoOV( OScrn,rgbuf,-1*cropx,(-1*cropy)+ (i*VLINES),w,VLINES); /* convert it */
  1034.          
  1035.     }
  1036.     printf ( " \n");
  1037.     telltime("Time to do all virtual processing ",clock1);
  1038.     fclose(fpl); /* close all files */
  1039.     fclose(fp1);
  1040.     fclose(fp2);
  1041.     remove(lumfn); remove(c1fn); remove(c2fn); /* remove temp files */
  1042.     free(lb1); free(lb2);/* let go of buffers we dont need them anymore */
  1043.              /* copy the data into the virtual screen */ 
  1044.     AutoSync24(asy);
  1045.     Err = (long)LowMemUpdate24 (OScrn,0);
  1046.     if ((Err>OL_ERR_MAXERR) && (!(OScrn->Flags&ILACE24)))
  1047.         {   AutoSync24 (asy);
  1048.           /*  Err = (long)LowMemUpdate24 (OScrn,6); */
  1049.         } 
  1050.         if ( (OScrn) && (fname) ){ /* we can save file */
  1051.             if (jpeg)
  1052.               a=SaveJPEG24(OScrn,fname,NULL, jpeg);
  1053.             else  
  1054.               a=SaveIFF24(OScrn,fname, NULL,NULL); 
  1055.             if (a) printf( "iff save error # %d couldn't save picture\n",a);
  1056.             else printf( "file saved as %s \n",fname);
  1057.         }  
  1058.         
  1059.         if (Err < OL_ERR_MAXERR)
  1060.         { CloseScreen24 ();
  1061.           if (Err==OL_ERR_OUTOFMEM)
  1062.             printf ("Out of memory!! \n");
  1063.           else if (Err==OL_ERR_CANTCLOSE)
  1064.             printf("OpalVision Display in Use.\n");
  1065.           else
  1066.             printf("Error Displaying image!! \n");
  1067.           cleanup(E_OVD);
  1068.         }    
  1069.         
  1070.           OVPriority();   
  1071.           Delay(10);
  1072.           
  1073.                      
  1074.      
  1075.      while ( *Button &0x040) { /* button for single show */
  1076.             Delay(10); }
  1077.     if ( backdrop){ /* we want to leave image as backdrop */
  1078.         AmigaPriority ();
  1079.         DualDisplay24 ();
  1080.         Delay (2L);
  1081.         LatchDisplay24 (TRUE);
  1082.         Delay (2L);
  1083.     }                    
  1084.     AmigaPriority();
  1085.     SingleDisplay24();
  1086.     FreeScreen24 (OScrn);
  1087.     CloseScreen24(); 
  1088.     return(0);    
  1089. }                                    
  1090.  
  1091.    
  1092.  
  1093. int DoOpal(int asy,int slide, char *fname) /* fill display and save OV */
  1094. {
  1095. int a,dw,dh,pic,slerr,orun;
  1096. UBYTE *rgbp[4];
  1097. long Err;
  1098.      /* assume the Opal Screen is already made */
  1099.      if (!OScrn) cleanup(E_OVD); /* but check to make sure */
  1100.      pic=1; slerr=0; orun=1; /* init variables */
  1101.      dw= OScrn->Width; /* get these from Opal Screen structure */
  1102.      dh= OScrn->Height;
  1103.         if (slide) pic= pstart; /* don't start at zero */
  1104.    
  1105.     /* below here updated for each pic, so loop on this ! */
  1106.     while (orun && (pic < 150)) {  /* keep doing this */ 
  1107.          rgbp[0]= Luma.im; /* set image area pointers */
  1108.          rgbp[1]= Chroma1.im;
  1109.          rgbp[2]= Chroma2.im;
  1110.          TurnOpal(OScrn,rgbp,cropx,cropy,dw,dh,turn); /* turn it */
  1111.          telltime("Picture loading & Decoding took",clock1);
  1112.    
  1113.              /* copy the data into the virtual screen */ 
  1114.                AutoSync24(asy);
  1115.          Err = (long)LowMemUpdate24 (OScrn,0);
  1116.         if ((Err>OL_ERR_MAXERR) && (!(OScrn->Flags&ILACE24)))
  1117.         {   AutoSync24 (asy);
  1118.           /*  Err = (long)LowMemUpdate24 (OScrn,6); */
  1119.         } 
  1120.         if ( (OScrn) && (fname) ){ /* we can save file */
  1121.             if (jpeg)
  1122.               a=SaveJPEG24(OScrn,fname,NULL, jpeg);
  1123.             else  
  1124.               a=SaveIFF24(OScrn,fname, NULL,NULL); 
  1125.             if (a) printf( "iff save error # %d couldn't save picture\n",a);
  1126.             else printf( "file saved as %s \n",fname);
  1127.         }  
  1128.         
  1129.         if (Err < OL_ERR_MAXERR)
  1130.         { CloseScreen24 ();
  1131.           if (Err==OL_ERR_OUTOFMEM)
  1132.             printf ("Out of memory!! \n");
  1133.           else if (Err==OL_ERR_CANTCLOSE)
  1134.             printf("OpalVision Display in Use.\n");
  1135.           else
  1136.             printf("Error Displaying image!! \n");
  1137.           cleanup(E_OVD);
  1138.         }    
  1139.         
  1140.         pic++;
  1141.         if (slide ) {
  1142.            
  1143.             slerr=GetNextPic(pic,0); 
  1144.             if (slerr ==9){
  1145.                printf("we hit last pic.  Starting over\n");
  1146.                 pic=1; Delay(60); /* go back and start over */
  1147.                 slerr=GetNextPic(pic,0); 
  1148.             }    
  1149.             if(slerr) orun=0; /* get the next file, if error,quit */
  1150.          /*   FadeOut24(25);*/
  1151.  
  1152.         }
  1153.         else orun=0;
  1154.         OVPriority();   
  1155.           Delay(10);
  1156.           
  1157.         if ( !(*Button & 0x040)) { /* button down for SLIDE */
  1158.             Delay(30); /* debounse */
  1159.             if (!(*Button & 0x040 )) orun=0; /* get out, is held down */
  1160.         }
  1161.               
  1162.     } 
  1163.      while ((*Button &0x040) && !(slide)){ /* button for single show */
  1164.             Delay(10); }
  1165.     if ( backdrop){ /* we want to leave image as backdrop */
  1166.         AmigaPriority ();
  1167.         DualDisplay24 ();
  1168.         Delay (2L);
  1169.         LatchDisplay24 (TRUE);
  1170.         Delay (2L);
  1171.     
  1172.     }                    
  1173.     FreeScreen24 (OScrn);
  1174.     CloseScreen24(); 
  1175.     return(0);    
  1176. }                                    
  1177.  
  1178. int GetNextPic(int pic,int res) /* slidesow, get next picture to OV */
  1179. {
  1180. static char *fn="CD0:PHOTO_CD/IMAGES/IMG0001.PCD";
  1181. int i,wm,ht;
  1182.     if(fin) fclose(fin); /* if it is open, close it */
  1183.     fin=NULL;
  1184.     if((pic>199) || (pic<0)) return(999); /* pic too high */
  1185.     wm=w/192; /* use to switch */
  1186.     ht= (pic/100); /* convert to digits */
  1187.     pic -= ht * 100; /* get it to 100 */
  1188.     *(fn+24)= h+48; 
  1189.  
  1190.     *(fn+25)=(pic/10)+48;
  1191.     *(fn+26)=(pic%10)+48;
  1192.     printf("filename is %s\n",fn); 
  1193.     
  1194.     fin=fopen(fn,"r");
  1195.     if(!fin)  return(9);
  1196.     switch(wm) { /* based on resolution */
  1197.         case 2 :    SEEK(L_Head+L_Base16+1); break;
  1198.         case 4 :    SEEK(L_Head+L_Base16+L_Base4+1) ; break;
  1199.         case 1 :    SEEK(L_Head+1); break;
  1200.         default: return(13);
  1201.     }
  1202.     Luma.iwidth=Luma.iheight=0;
  1203.     Chroma1.iwidth=Chroma1.iheight=0;
  1204.     Chroma2.iwidth=Chroma2.iheight=0;
  1205.     i=readplain(w,h,&Luma,&Chroma1,&Chroma2);
  1206.     if (fin) { fclose(fin); fin=NULL; }
  1207. /*     printf( "plane read %d w %d h %d i \n",w,h,i); */
  1208.     if(i) return(i); /* an error here break */
  1209.     interpolate(&Chroma1); 
  1210.     interpolate(&Chroma2); 
  1211.     ycctorgb(w,h,&Luma,&Chroma1,&Chroma2);
  1212.                     
  1213.       return(0); /* successful */
  1214. }
  1215.  
  1216. int TurnOpal( Oscr, rgbp, xos,yos,dw,dh,dir)
  1217. struct OpalScreen *Oscr;
  1218. UBYTE   *rgbp[3]; /* pointers for decoded Photo CD data */
  1219. int xos,yos,dw,dh,dir; /* offset and size of image, and dir 0=no 1=r else l 
  1220.         do cropping here, if unable to open screen, stash in file and 
  1221.         reload down the line */
  1222. {  /* this is to view images on edge.  To save memory we only buffer
  1223.     16 lines */
  1224. long size,lines;
  1225. int i,j,ystep;
  1226. UBYTE *buf,*rgbuf[3],*rp,*gp,*bp; /* pointers into array */
  1227.     lines=16;
  1228.     size=h*3*lines; /* well do 16 lines (initially columns ) at a time */
  1229.     buf=malloc(size); /* try to allocate the memory */
  1230.     rp=rgbuf[0]=buf;
  1231.     gp=rgbuf[1]=buf+(h*lines);/* set pointer */
  1232.     bp=rgbuf[2]=buf+(h*lines*2);
  1233.     
  1234.     if ( !buf) { 
  1235.         printf("can't allocate turn buffer, try closing some windows \n");        
  1236.         cleanup(E_MEM);
  1237.     }
  1238.     if (crop) { xos *= -1; /* invert since pcd larger than Opal */
  1239.                 yos *= -1;
  1240.             }
  1241.     if ( dir==0) { 
  1242.         RGBtoOV ( OScrn,rgbp,xos,yos,w,h );
  1243.         return(3); /* do this step here */ 
  1244.     }
  1245.     if (turn==1) { /* right turn */
  1246.         /* start from bottom left j=column turned to row */
  1247.         for(j=0; j<w; j++){   
  1248.            for(i=h-1; i>=0; i--) { /* count up from bottom build one line*/
  1249.                 ystep=(i*w)+j;
  1250.                 *rp++=*(rgbp[0]+ ystep); /* copy pixels for each color */
  1251.                 *gp++=*(rgbp[1]+ ystep);
  1252.                 *bp++=*(rgbp[2]+ ystep);        
  1253.            }
  1254.            if(  ( ( j& 0x0F )==0x0f) || (j == w-1)) { /* update ea 16 lines*/
  1255.                 rp=rgbuf[0]; /* eset pointers to bases */
  1256.                 gp=rgbuf[1];
  1257.                 bp=rgbuf[2];
  1258.                 RGBtoOV( Oscr,rgbuf,xos,yos+j-lines+1,h,lines); /* convert it */
  1259.            
  1260.             }
  1261.            
  1262.         }
  1263.      }   
  1264.      else { /* left  turn */
  1265.         /* start from bottom left j=column turned to row */
  1266.         for(j=w-1; j>=0; j--){   
  1267.            for(i=0; i<h; i++) { /* count down build one line*/
  1268.                 ystep=(i*w)+j;
  1269.                 *rp++=*(rgbp[0]+ ystep); /* copy pixels for each color */
  1270.                 *gp++=*(rgbp[1]+ ystep);
  1271.                 *bp++=*(rgbp[2]+ ystep);        
  1272.            }
  1273.            if(   ( j& 0x0F )==0x00) { /* update ea 16 lines*/
  1274.                 rp=rgbuf[0]; /* reset pointers to bases */
  1275.                 gp=rgbuf[1];
  1276.                 bp=rgbuf[2];
  1277.                 RGBtoOV( Oscr,rgbuf,xos,yos+w-j-lines,h,lines); /* convert it */
  1278.            
  1279.             }
  1280.         }     
  1281.      }
  1282.      free(buf); /* let it go, we dont need it anymore */
  1283.      return(j);
  1284.  
  1285.         
  1286.  
  1287. }
  1288.  
  1289. int  storeplane(implane *imp,char *fn)
  1290. { /* store a plane in a file, return 0 if OK, else error */
  1291. FILE *fps;
  1292. int a;
  1293.     fps = fopen(fn,"w"); /* open it */
  1294.     if (!fps) return(1); /* error if not open */
  1295.     a=fwrite( &ih,16,1,fps); /* write header, use default */
  1296.     a=fwrite( imp->im,imp->iwidth,imp->iheight,fps); 
  1297.     fclose(fps); /* close the file no matter what */   
  1298.     if ( a < imp->iheight) return (a+1);
  1299.     return(0); /* we are successful */
  1300. }
  1301.  
  1302. enum ERRORS readplain(w,h,l,c1,c2)
  1303. dim w,h;
  1304. implane *l,*c1,*c2;
  1305. {
  1306. dim i;
  1307. byte *pl=0,*pc1=0,*pc2=0;
  1308.  
  1309.   if(l)
  1310.    { if ((l->mwidth<w) || (l->mheight<h) || (!l->im)) cleanup(E_INTERN);
  1311.      l->iwidth=w;
  1312.      l->iheight=h;
  1313.      pl=l->im;
  1314.    }
  1315.  
  1316.   if(c1)
  1317.    { if ((c1->mwidth<w/2) || (c1->mheight<h/2) || (!c1->im)) cleanup(E_INTERN);
  1318.      c1->iwidth=w/2;                    /* Make sure theyre big enough */
  1319.      c1->iheight=h/2;
  1320.      pc1=c1->im;
  1321.    }
  1322.  
  1323.   if(c2)
  1324.    { if ((c2->mwidth<w/2) || (c2->mheight<h/2) || (!c2->im)) cleanup(E_INTERN);
  1325.      c2->iwidth=w/2;
  1326.      c2->iheight=h/2;
  1327.      pc2=c2->im;
  1328.    }
  1329.  
  1330.   for(i=0;i<h/2;i++)
  1331.    {
  1332.     if(pl)
  1333.      { 
  1334.        if(fread(pl,w,1,fin)<1) return(E_READ);
  1335.        pl+= l->mwidth;
  1336.  
  1337.        if(fread(pl,w,1,fin)<1) return(E_READ);
  1338.        pl+= l->mwidth;
  1339.      }
  1340.     else SKIPr(2*w);
  1341.      
  1342.     if(pc1)
  1343.      { if(fread(pc1,w/2,1,fin)<1) return(E_READ);
  1344.        pc1+= c1->mwidth;
  1345.      }
  1346.     else SKIPr(w/2);
  1347.      
  1348.     if(pc2)
  1349.      { if(fread(pc2,w/2,1,fin)<1) return(E_READ);
  1350.        pc2+= c2->mwidth;
  1351.      }
  1352.     else SKIPr(w/2);
  1353.  
  1354.  
  1355.    }
  1356. #ifdef DEBUG
  1357. fprintf(stderr,"R-Position %x\n",ftell(fin));
  1358. #endif
  1359.   return E_NONE;
  1360.  }
  1361.  
  1362.  
  1363. static void interpolate(implane *p)
  1364. {
  1365. dim w,h,x,y,yi,h2,w2;
  1366. byte *optr,*nptr,*uptr;
  1367.  
  1368.   if ((!p) || (!p->im)) cleanup(E_INTERN);
  1369.  
  1370.   w=p->iwidth;
  1371.   h=p->iheight;
  1372.  
  1373.   if(p->mwidth  < 2*w ) cleanup(E_INTERN);
  1374.   if(p->mheight < 2*h ) cleanup(E_INTERN);
  1375.  
  1376.  
  1377.   w2=p->iwidth =2*w;
  1378.   h2=p->iheight=2*h;/* cut some multiplications by doing once at start */ 
  1379.  
  1380.  
  1381.   for(y=0;y<h;y++) /* each line */
  1382.    {yi=h-1-y; /* start from bottom near END */
  1383.     optr=p->im+  yi*p->mwidth + (w-1);/* old pointer USES MAX WID starts 1/2 way*/
  1384.     nptr=p->im+((yi*p->mwidth)<<1) + (w2 - 2); /* starts near end and works back*/
  1385.  
  1386.     nptr[0]=nptr[1]=optr[0]; /* set these two end points to oldpoint*/
  1387.  
  1388.     for(x=1;x<w;x++)/* do this #of times of current width */
  1389.      { optr--; nptr-=2; /* drop old ptr by 1 and new by 2 */
  1390.        nptr[0]=optr[0]; /* set the even point equal */
  1391.        nptr[1]=(((short)optr[0])+((short)optr[1]))>>1; /* odd pt is avg between
  1392.             this point and next point in X direction */
  1393.      }              /* try sub divede by 2 with >>1 */    }
  1394.  
  1395.   for(y=0;y<h-1;y++)  /* this reads between the lines */
  1396.    {optr=p->im + ((y*p->mwidth)<<1);
  1397.     nptr=optr+p->mwidth;
  1398.     uptr=nptr+p->mwidth;
  1399.  
  1400.     for(x=0;x<w2;x++)
  1401.       *(nptr++)=(((short)*(optr++))+((short)*(uptr++)))>>1;
  1402.    }
  1403.  
  1404.   bcopy(p->im + (h2-2)*p->mwidth, p->im + (h2-1)*p->mwidth,  w2);
  1405.  
  1406.  }
  1407.  
  1408. void telltime(tmsg, clock1) /* tell elapsed time, array at start is passed */
  1409. unsigned int clock1[2];
  1410. char *tmsg;
  1411. {
  1412. unsigned int x;
  1413. double t;
  1414.     x=timer(clock2); /* get time I came out of it */
  1415.     if( clock2[1] < clock1[1]) { /* take care of uS rollover */
  1416.         clock2[1]+= 1000000L;
  1417.         clock2[0]--; }
  1418.         
  1419.     clock2[1]-=clock1[1]; /* get diff in us */
  1420.     clock2[0]-=clock1[0];
  1421.     t=(double) (clock2[1]/1000000.0) +(double)clock2[0];
  1422.     printf( "%s %8.3f Sec.  \n",tmsg,t);
  1423.  }
  1424.  
  1425. static void ycctorgb(w,h,l,c1,c2)
  1426. dim w,h;
  1427. implane *l,*c1,*c2;
  1428. {
  1429. register dim x,y,i;
  1430. register  byte *pl,*pc1,*pc2;
  1431.  short red,green,blue;
  1432.   float L;
  1433.   static int init=0;
  1434.   static float XL[256],XC1[256],XC2[256],XC1g[256],XC2g[256];
  1435. /*
  1436.   if((!l ) || ( l->iwidth != w ) || ( l->iheight != h) || (! l->im)) cleanup(E_INTERN);
  1437.   if((!c1) || (c1->iwidth != w ) || (c1->iheight != h) || (!c1->im)) cleanup(E_INTERN);
  1438.   if((!c2) || (c2->iwidth != w ) || (c2->iheight != h) || (!c2->im)) cleanup(E_INTERN);
  1439. */
  1440.   if(do_sharp) sharpit(l);
  1441.  
  1442.  
  1443.   if(!init)
  1444.    {init=1;
  1445.     for(i=0;i<256;i++)
  1446.      { XL[i]=1.3584 *  ((float)i );
  1447.       XC1[i]=2.2179 * (((float)i)-156.0);
  1448.       XC2[i]=1.8215 * (((float)i)-137.0);
  1449.       XC1g[i]= -0.194 * XC1[i];
  1450.       XC2g[i]= -0.509 * XC2[i];
  1451.      }
  1452.    }
  1453.  
  1454.  
  1455.  
  1456.   for(y=0;y<h;y++)
  1457.    {
  1458.     pl =  l->im + y *  l->mwidth;
  1459.     pc1= c1->im + y * c1->mwidth;
  1460.     pc2= c2->im + y * c2->mwidth;
  1461.  
  1462.     for(x=0;x<w;x++)
  1463.      {
  1464.      L = XL[*pl]; 
  1465.  
  1466.      red  =L + XC2[*pc2];
  1467.      green=L + XC1g[*pc1] + XC2g[*pc2]; 
  1468.      blue =L + XC1[*pc1];
  1469.  
  1470.      NORM(red);
  1471.      NORM(green);
  1472.      NORM(blue);
  1473.  
  1474.       *(pl++ )=red; 
  1475.       *(pc1++)=/*green */ green; 
  1476.       *(pc2++)=blue;
  1477.      }
  1478.  /*   printf("line %d raw is %d %d %d \n",y,*pl,*pc1,*pc2); */
  1479.    }
  1480.  
  1481.  }
  1482.  
  1483.  
  1484. static void druckeid()
  1485. {
  1486.  struct ph1 *d;
  1487.  char ss[100];
  1488.  
  1489.  SEEK(1);
  1490.  if(READBUF<1) cleanup(E_READ);
  1491.  d=(struct ph1 *)sbuffer;
  1492.  
  1493. #define dr(feld,kennung)   \
  1494.     strncpy(ss,feld,sizeof(feld));\
  1495.     ss[sizeof(feld)]=0;\
  1496.     fprintf(stderr,"%s: %s \n",kennung,ss);
  1497.     dr(d->id1,"Id1")
  1498.     dr(d->id2,"Id2")
  1499.     dr(d->id3,"Id3")
  1500.     dr(d->id4,"Id4")
  1501.     dr(d->id5,"Id5")
  1502.     #undef dr 
  1503.     }
  1504.  
  1505. struct pcdword
  1506.  { byte high,low;
  1507.  };
  1508.  
  1509.  
  1510.  
  1511.  
  1512. struct pcdquad { byte len,highseq,lowseq,key;}; /* size=4 */
  1513. struct pcdhqt  { byte entries; struct pcdquad entry[256];}; /* size=1025*/
  1514. struct myhqt { unsigned long seq,mask,len; byte key; }; /* size=13 */
  1515.  
  1516.  
  1517. #define E ((unsigned long) 1)
  1518.  
  1519.  
  1520. static void readhqtsub(source,ziel,anzahl)
  1521.   struct pcdhqt *source;
  1522.   struct myhqt *ziel;
  1523.   int *anzahl;
  1524.  {int i;
  1525.   struct pcdquad *sub;
  1526.   struct myhqt *help;
  1527.   *anzahl=source->entries+1;
  1528.  
  1529.   for(i=0;i<*anzahl;i++)
  1530.    {sub= source->entry+i;
  1531.     help=ziel+i;
  1532.  
  1533.     help->seq = (((unsigned long) sub->highseq) << 24) |(((unsigned long) sub->lowseq) << 16);
  1534.     help->len = ((unsigned long) sub->len) +1;
  1535.  
  1536.     if(help->len > 16) cleanup(E_HUFF);
  1537.  
  1538.     help->key = sub->key;
  1539.     help->mask = ~ ( (E << (32-help->len)) -1); 
  1540.  
  1541.   }
  1542. #ifdef DEBUG
  1543.   for(i=0;i<*anzahl;i++)
  1544.    {help=ziel+i;
  1545.     fprintf(stderr,"H: %3d  %08lx & %08lx (%2d) = %02x = %5d  %8x\n",
  1546.         i, help->seq,help->mask,help->len,help->key,(signed char)help->key,
  1547.         help->seq & (~help->mask));
  1548.    }
  1549. #endif
  1550.  
  1551. }
  1552.  
  1553. static struct myhqt myhuffl[256],myhuff1[256],myhuff2[256];
  1554. static int          myhufflenl=0,myhufflen1=0,myhufflen2=0;
  1555.  
  1556. static void readhqt(w,h,n)
  1557.   dim w,h,n;
  1558.  {
  1559.   byte *ptr; /* fix type to placate compiler 3-6-93 */
  1560.   int a;
  1561.   if ( n==3 ) { /* if for decompressing highest get 2 sectors */
  1562.     a=fread(sbuffer,1,4000,fin); }
  1563.   else          a=READBUF; /* else, for second highest, get only 1 sector */
  1564.   if(a ==0 ) cleanup(E_READ);
  1565.   ptr = sbuffer;
  1566.  
  1567.   readhqtsub((struct pcdhqt *) ptr,myhuffl,&myhufflenl);
  1568.  
  1569.   if(n<2) return;
  1570.   ptr+=  4* myhufflenl;
  1571.   ptr++;
  1572.   readhqtsub((struct pcdhqt *) ptr,myhuff1,&myhufflen1);
  1573.   if(n<3) return;
  1574.   ptr+=  4* myhufflen1;
  1575.   ptr++;
  1576.   readhqtsub((struct pcdhqt *) ptr,myhuff2,&myhufflen2);
  1577.  /* printf( " Length of hqts %d\n",ptr-sbuffer); */
  1578. }
  1579.  
  1580.  
  1581. #define nextbuf  {  nptr=sbuffer;  if(READBUF < 1) cleanup(E_READ);\
  1582.         }
  1583. #define checkbuf { if (nptr >= sbuffer + sizeof(sbuffer)) nextbuf; }
  1584. #define shiftout(n){ sreg<<=n; inh-=n; \
  1585.                      while (inh<=24) \
  1586.                       {checkbuf; \
  1587.                        sreg |= ((unsigned long)(*(nptr++)))<<(24-inh);\
  1588.                        inh+=8;\
  1589.                       }\
  1590.                     }  
  1591.  
  1592. /* I think the following routine is screwed since it works OK up to
  1593.    its usage 3/8/93 readhqt not called anymire */
  1594.    
  1595.  
  1596.  
  1597. static void decompress(w,h,f,f1,f2)
  1598.   dim w,h;
  1599.   implane *f,*f1,*f2;
  1600.  {
  1601.   register int i,htlen,sum;
  1602.   unsigned long sreg,maxwidth;
  1603.   unsigned int inh,n,zeile,segment,ident,j;
  1604.   struct myhqt *htptr,*hp;
  1605.   
  1606.   byte *nptr;
  1607.   byte *lptr;
  1608.  
  1609. /* try bypass this so we can decompress Chroma only */
  1610. /* 
  1611.   if((!f) || (!f->im)) cleanup(E_INTERN);
  1612.   if((f->iheight < h) || (f->iwidth<w)) cleanup(E_INTERN); */
  1613.   maxwidth=f->mwidth; 
  1614.   if (!f) maxwidth=w;
  1615.   sreg=0x0000;
  1616.   nextbuf;
  1617.   inh=32;
  1618.   lptr=0;
  1619.   shiftout(16);
  1620.   shiftout(16); 
  1621.  
  1622.   n=0;
  1623.   for(;;) /* keeps going and going*/
  1624.   {
  1625.     if((sreg & 0xffffff00) == 0xfffffe00)
  1626.      {shiftout(24);
  1627.       ident=sreg>>16;
  1628.       shiftout(16);
  1629.  
  1630.       zeile=(ident>>1) & 0x1fff;
  1631.       segment=ident>>14;
  1632.        /* the loop passes here about once each line */
  1633. /*      if (!( zeile & 127))  /* do each 16th line */
  1634.         fprintf(stderr,"Ident %4x Zeile:  %6d  Segment %3d Pixels bisher: %d\n",
  1635.           ident,zeile,segment,n);*/
  1636.  
  1637.       if(lptr && (n!=maxwidth)) cleanup(E_SEQ1);
  1638.       n=0;
  1639.  
  1640. /* zeile must mean height in pixel rows */
  1641.       if(zeile==h) return; /* WERE DONE */
  1642.       
  1643.       if(zeile > h) cleanup(E_SEQ2);
  1644.  
  1645.       switch(segment)
  1646.        {
  1647.         case 0: htlen=myhufflenl;
  1648.                 htptr=myhuffl;
  1649.                
  1650.                  if(!f ){ /* do this if luma not used */
  1651.                     lptr=NULL;            
  1652.                     maxwidth=w;
  1653.  
  1654.  
  1655.                     }  /* to placate things */
  1656.                 else { 
  1657.                     lptr=f->im + zeile*f->mwidth; /* set pointer */
  1658.                     maxwidth=f->iwidth;
  1659.                 }
  1660.                 break;
  1661.  
  1662.         case 2: if(!f1) return; /* were doing MONOCHROME only */
  1663.                 if ( virt &&  f && f1) { /* size 5, virtual mode
  1664.                     and have NOT done a chroma hunk yet we need to do some stuff*/
  1665.                     ih.width=w; ih.height=h; /* Luma plane is FULL size*/
  1666.                     j= storeplane(f,lumfn);
  1667.                     planefree(&Luma); /* free it up */
  1668.                     f=0L; /* set luma plane to 0, we dont need it anymore */
  1669.                     if (j) { printf("Error %d storing Luma file, too little disk space? \n",j);
  1670.                           cleanup(E_WRITE); }
  1671.                     ih.width=w/2; ih.height=h/2; /* chroma planes 1/4 size*/
  1672.                    
  1673.                     planealloc(f1,w/2,h/2); /* just do max detail1536x1024*/ 
  1674.                     planealloc(f2,w/2,h/2); /* these two take about 3Meg*/
  1675.                     for( j=0; j< 256; j++) { /* align lines to max width to conform */
  1676.                         memcpy(f1->im+(j*w/2),C1t.im+(384*j),384); /* copy temps over */
  1677.                         memcpy(f2->im+(j*w/2),C2t.im+(384*j),384); /* copy temps over */
  1678.                     } /* space the 384x256 chroma to be interpolated */
  1679.                     planefree(&C1t); /* get rid of temp chroma */
  1680.                     planefree(&C2t);
  1681.                     printf("Interpolating chroma  \n");
  1682.                     f1->iheight=f2->iheight=h/8; /* only 368x256*/
  1683.                     f1->iwidth =f2->iwidth =w/8;
  1684.                     interpolate(f1);
  1685.                     interpolate(f1);
  1686.                     interpolate(f2);
  1687.                     interpolate(f2);  /* NOW interpolate it out x4 each dir*/
  1688.                     printf("really Starting to decompress Chroma\n");
  1689.                  
  1690.                     /* we are all ready to go */
  1691.                     /* BTW f=Luma, f1=Chroma1 and f2=Chroma2 planes */
  1692.                 }
  1693.                 if (!f1->im) cleanup(E_SEQ7); /* cover allocation errors */    
  1694.                 lptr=f1->im + (zeile>>1)*f1->mwidth;
  1695.                 maxwidth=f1->iwidth;
  1696.                 htlen=myhufflen1;
  1697.                 htptr=myhuff1;
  1698.                 break;
  1699.  
  1700.         case 3: if(!f2) cleanup(E_SEQ7);
  1701.                 if(!f2->im) cleanup(E_SEQ7);
  1702.                 lptr=f2->im + (zeile>>1)*f2->mwidth;
  1703.                 maxwidth=f2->iwidth;
  1704.                 htlen=myhufflen2;
  1705.                 htptr=myhuff2;
  1706.                 if(zeile >= (h-9)) return; /* break off a little early */
  1707.            /* TEMP FIX FOR BUG IN SYSTEM READ OF LAST SECTOR.
  1708.              CHROMA RESOLUTION SLIGHTLY LOWER ON BOTTOM 4 LINES */     
  1709.                 break;
  1710.  
  1711.         default:cleanup(E_SEQ3);
  1712.     } /* end of segment case statement */
  1713.   }
  1714.   else
  1715.   { /* DECOMPRESS THE PIXEL */
  1716.       if(n>maxwidth)/* cleanup(E_SEQ4);*/
  1717.          {printf("Nonfatal err4 line %d seg %d  \n",zeile,segment); return; }
  1718.       for(i=0,hp=htptr;(i<htlen) && ((sreg & hp->mask)!= hp->seq); i++,hp++);
  1719.       if(i>=htlen) cleanup(E_SEQ5);
  1720.       if (lptr) { /* if we are not saving, skip this much */  
  1721.         sum=((int)(*lptr)) + ((int)hp->key);
  1722.         /* add decompressed data to pixel */
  1723.         *(lptr++) = sum & 0xff ;
  1724.         /* ---THIS SEEMS TO HAVE FIXED THE PROBLEM,
  1725.             BAZZ 3-10-93! CHANGING NORM TO & 0XFF ; */
  1726.         n++; 
  1727.        } 
  1728.       shiftout(hp->len);
  1729.  
  1730.    } /* END OF ELSE ROUTINE */
  1731.  
  1732.  } /* END OF FOR(;;) INDEFINATE LOOP */
  1733.  
  1734.  
  1735.  
  1736. } /* END OF DECOMPRESS SUBROUTINE */
  1737.  
  1738.  
  1739.  
  1740.  
  1741. static void clear(l,n)
  1742.   implane *l;
  1743.   int n;
  1744. { dim x,y;
  1745.   byte *ptr;
  1746. /*  l->iwidth=l->mwidth;
  1747.   l->iheight=l->mheight;
  1748. */
  1749.   ptr=l->im;
  1750.   for (x=0;x<l->mwidth;x++)
  1751.     for (y=0; y<l->mheight;y++)
  1752.       *(ptr++)=n;
  1753. }
  1754.  
  1755.  
  1756. static void sharpit(l)
  1757.   implane *l;
  1758.  {int x,y,h,w,mw,akk;
  1759.   byte f1[slen],f2[slen],*old,*akt,*ptr,*work,*help,*optr;
  1760.  
  1761.   if((!l) || (!l->im)) cleanup(E_INTERN);
  1762.   if(l->iwidth > slen) cleanup(E_INTERN);
  1763.  
  1764.   old=f1; akt=f2;
  1765.   h=l->iheight;
  1766.   w=l->iwidth;
  1767.   mw=l->mwidth;
  1768.  
  1769.   for(y=1;y<h-1;y++)
  1770.    {
  1771.     ptr=l->im+ y*mw;
  1772.     optr=ptr-mw;
  1773.     work=akt;
  1774.  
  1775.     *(work++)= *(ptr++);
  1776.     for(x=1;x<w-1;x++)
  1777.      {  akk = 5*((int)ptr[0])- ((int)ptr[1])  - ((int)ptr[-1]) 
  1778.                               - ((int)ptr[mw]) - ((int)ptr[-mw]);
  1779.         NORM(akk);
  1780.         *(work++)=akk;
  1781.         ptr++;
  1782.      }
  1783.  
  1784.     *(work++)= *(ptr++);
  1785.  
  1786.     if(y>1) bcopy(old,optr,w);
  1787.     help=old;old=akt;akt=help;
  1788.      
  1789.    }
  1790.  
  1791.   bcopy(old,optr+mw,w);
  1792.  }
  1793.  
  1794. int Display_Mode_Check (void)
  1795. { /* see if we are in high res */
  1796.    struct MonitorInfo MonitorInfo;
  1797.    DisplayInfoHandle Handle;
  1798.    ULONG ModeID;
  1799.    LONG Result;
  1800.  
  1801.     GfxBase = (struct GfxBase *)OpenLibrary ("graphics.library",36L);
  1802.     if (GfxBase==NULL) return (TRUE);
  1803.     IntuitionBase = (struct IntuitionBase *)OpenLibrary ("intuition.library",0L);
  1804.     if (IntuitionBase==NULL)
  1805.         { CloseLibrary ((struct Library *)GfxBase);
  1806.           return (TRUE);
  1807.         }
  1808.     ModeID = GetVPModeID (&IntuitionBase->FirstScreen->ViewPort);
  1809.     Handle = FindDisplayInfo (ModeID);
  1810.     Result = GetDisplayInfoData (Handle,(UBYTE *)&MonitorInfo,
  1811.             sizeof (struct MonitorInfo),DTAG_MNTR,NULL);
  1812.  
  1813.     /*  If line frequency if >15Khz, a backdrop
  1814.      * cannot be displayed.
  1815.      */
  1816.  
  1817.     if (MonitorInfo.TotalColorClocks<220)
  1818.         { CloseLibrary ((struct Library *)GfxBase);
  1819.           CloseLibrary ((struct Library *)IntuitionBase);
  1820.           return (FALSE);
  1821.         }
  1822.     CloseLibrary ((struct Library *)GfxBase);
  1823.     CloseLibrary ((struct Library *)IntuitionBase);
  1824.     return (TRUE);
  1825. }
  1826.  
  1827.